home *** CD-ROM | disk | FTP | other *** search
/ Games of Daze / Infomagic - Games of Daze (Summer 1995) (Disc 1 of 2).iso / x2ftp / msdos / memory / xms100pc / xmmlib.h < prev    next >
C/C++ Source or Header  |  1994-09-20  |  11KB  |  286 lines
  1. //===========================================================================
  2. //
  3. //  XMMLIB.H -- Header file for XMMLIB routines, Copyright 1994, Paul Chang
  4. //
  5. //---------------------------------------------------------------------------
  6. //
  7. //  Credit:
  8. //
  9. //    This code was developed based on the XMS version 2.0 specification,
  10. //    copyright (c) 1988, Microsoft Corporation, Lotus Development
  11. //    Corporation, Intel Corporation, and AST Research, Inc.
  12. //
  13. //---------------------------------------------------------------------------
  14. //
  15. //  Legal speak:
  16. //
  17. //    This code is public domain and free, and may be distributed free of any
  18. //    charge or royalty, in the spirit of free software.
  19. //
  20. //    All code, including source, object, and executable, may be used, free
  21. //    of any charge and royalty, provided that the developer gives credit
  22. //    to the original author should any of said code be used in either
  23. //    public domain or commercial software products.
  24. //
  25. //    The developer may use this code with the understanding that the
  26. //    original author is in no way held responsible for any damage that may
  27. //    arise from usage of any of said code.
  28. //
  29. //    Usage of said code includes incorporation into larger programs,
  30. //    possible alteration of original code, and redistribution.
  31. //
  32. //---------------------------------------------------------------------------
  33. //
  34. //  Translation:
  35. //
  36. //    You can give this code away for free because this code is free.
  37. //
  38. //    You can use this code for free, but if you decide to build something
  39. //    useful with it, give me some credit, will you?
  40. //
  41. //    If you use this code and it somehow screws you or your system over,
  42. //    I'm not responsible, because I told you so.  Besides, I'm too poor
  43. //    to be sued.
  44. //
  45. //    You can compile stuff with this code, you can even change this code,
  46. //    and you can redistribute it, as long as you play nice and give me
  47. //    some credit.
  48. //
  49. //---------------------------------------------------------------------------
  50. //
  51. //  Why is this freeware?
  52. //
  53. //    Because I doubt that anything I write could be commercially successful.
  54. //    Besides, I have a job that feeds me, so I don't really need your
  55. //    money.
  56. //
  57. //  Why do I include source code?
  58. //
  59. //    Because I know how frustrating it is to link a library without having
  60. //    the ability to look at the source code.
  61. //
  62. //  Why do I give you permission to alter code?
  63. //
  64. //    Because I know how frustrating it is to link a library without having
  65. //    the ability to alter the source code.
  66. //
  67. //  Why do I want you to give me some credit?
  68. //
  69. //    Because I've spent some time on this code, and I'd like to be
  70. //    recognized for that effort if you choose to use it.
  71. //
  72. //  Why is this written in C++?
  73. //
  74. //    Because I hate C.  Besides, double-slash comments are nice.  If you
  75. //    don't like it, tough -- try writing your OWN XMM library then.
  76. //
  77. //===========================================================================
  78.  
  79. #ifndef _XMMLIB_H
  80. #define _XMMLIB_H
  81.  
  82. //---------------------------------------------------------------------------
  83. //
  84. //  XMM Function Numbers
  85. //
  86. //---------------------------------------------------------------------------
  87.  
  88. //  To check if XMM is installed, int 2Fh is called with AX=4300h and the
  89. //  contents of AL are compared to 0x80.  This is confusing, because most XMM
  90. //  functions return 0x80 when a particular function is not implemented.  To
  91. //  obtain the address of the XMM control function, call int 2Fh once again,
  92. //  only with AX=4310h, and the address of the XMM control function is
  93. //  returned in ES:BX.  This control function is referenced in all subsequent
  94. //  XMM API calls.
  95.  
  96. #define XMM_CALL        0x2f
  97. #define XMM_INSTALL        0x4300
  98. #define XMM_INSTALLED        0x80
  99. #define XMM_CONTROL        0x4310
  100.  
  101. //  XMM control functions
  102.  
  103. #define XMM_GET_VERSION        0x00
  104. #define XMM_REQUEST_HMA        0x01    //  Not implemented -- dangerous!
  105. #define XMM_RELEASE_HMA        0x02    //  Not implemented -- dangerous!
  106. #define XMM_ENABLE_A20        0x03    //  Not implemented -- dangerous!
  107. #define XMM_DISABLE_A20        0x04    //  Not implemented -- dangerous!
  108. #define XMM_LOC_ENABLE_A20    0x05    //  Not implemented -- dangerous!
  109. #define XMM_LOC_DISABLE_A20    0x06    //  Not implemented -- dangerous!
  110. #define XMM_QUERY_A20        0x07    //  Not implemented -- dangerous!
  111. #define    XMM_QUERY_FREE        0x08
  112. #define XMM_ALLOCATE_BLOCK    0x09
  113. #define XMM_FREE_BLOCK        0x0A
  114. #define XMM_MOVE_MEMORY        0x0B
  115. #define XMM_LOCK_BLOCK        0x0C
  116. #define XMM_UNLOCK_BLOCK    0x0D
  117. #define XMM_GET_HANDLE_INFO    0x0E
  118. #define XMM_REALLOC_BLOCK    0x0F
  119. #define XMM_REQUEST_UMB        0x10    //  Not implemented -- I'm lazy!
  120. #define XMM_RELEASE_UMB        0x11    //  Not implemented -- I'm lazy!
  121. #define XMM_REALLOC_UMB        0X12    //  Not implemented -- I'm lazy!
  122. #define XMM_SUPER_QUERY_FREE    0X88    //  Don't use Super XMS functions yet!
  123. #define XMM_SUPER_ALLOCATE    0X89    //  Don't use Super XMS functions yet!
  124. #define XMM_SUPER_GET_INFO    0X8E    //  Don't use Super XMS functions yet!
  125. #define XMM_SUPER_REALLOC    0X8F    //  Don't use Super XMS functions yet!
  126.  
  127. //---------------------------------------------------------------------------
  128. //
  129. //  XMM error codes
  130. //
  131. //---------------------------------------------------------------------------
  132.  
  133. //  Most XMM functions will return an error code in BX if AX contains 0x0000,
  134. //  signalling an error.  Otherwise, AX will usually return 0x0001.
  135.  
  136. #define XMM_NOT_IMPLEMENTED    0x80    //  Means function is not implemented
  137. #define XMM_VDISK_DETECTED    0x81    //  Means VDISK was found
  138. #define XMM_A20_ERROR        0x82    //  Means A20 error occurred
  139. #define XMM_DRIVER_ERROR    0x8E    //  Means general driver error occurred
  140. #define XMM_FATAL_ERROR        0x8F    //  Means unrecoverable driver error
  141. #define XMM_NO_HMA        0x90    //  Means no HMA available
  142. #define XMM_HMA_IN_USE        0x91    //  Means HMA already in use
  143. #define XMM_DX_LESS_HMAMIN    0x92    //  Means DX < HMAMIN
  144. #define XMM_HMA_NO_ALLOC    0x93    //  Means HMA was not allocated
  145. #define XMM_A20_ENABLED        0x94    //  Means A20 line still enabled
  146. #define XMM_NO_FREE_EMB        0xA0    //  Means all EMBs allocated
  147. #define XMM_NO_FREE_HANDLE    0xA1    //  Means all handles allocated
  148. #define XMM_INVALID_HANDLE    0xA2    //  Means invalid handle
  149. #define XMM_BAD_SOURCE_HANDLE    0xA3    //  Means source handle is invalid
  150. #define XMM_BAD_SOURCE_OFFSET    0xA4    //  Means source offset is invalid
  151. #define XMM_BAD_DEST_HANDLE    0xA5    //  Means destination handle is invalid
  152. #define XMM_BAD_DEST_OFFSET    0xA6    //  Means destination offset is invalid
  153. #define XMM_BAD_LENGTH        0xA7    //  Means length is invalid
  154. #define XMM_BAD_OVERLAP        0xA8    //  Means move has invalid overlap
  155. #define XMM_PARITY_ERROR    0xA9    //  Means parity error occurred
  156. #define XMM_BLOCK_NOT_LOCKED    0xAA    //  Means the block is not locked
  157. #define XMM_BLOCK_LOCKED    0xAB    //  Means the block is locked
  158. #define XMM_BLOCK_COUNT        0xAC    //  Means locked block count overflowed
  159. #define XMM_LOCK_FAILED        0xAD    //  Means lock failed
  160. #define XMM_SMALLER_UMB        0xB0    //  Means smaller UMB is available
  161. #define XMM_NO_UMB        0xB1    //  Means no UMB available
  162. #define XMM_BAD_UMB_SEG        0xB2    //  Means bad UMB segment number
  163.  
  164. //---------------------------------------------------------------------------
  165. //
  166. //  Macros
  167. //
  168. //---------------------------------------------------------------------------
  169.  
  170. //  Far pointer conversion macros were snarfed from Borland C++ dos.h file
  171.  
  172. #ifndef MK_FP
  173. #  define MK_FP( seg,ofs )( (void _seg * )( seg ) + ( void near * )( ofs ))
  174. #endif MK_FP
  175.  
  176. #ifndef FP_SEG
  177. #  define FP_SEG( fp )( (unsigned )( void _seg * )( void far * )( fp ))
  178. #endif FP_SEG
  179.  
  180. #ifndef FP_OFF
  181. #  define FP_OFF( fp )( (unsigned )( fp ))
  182. #endif FP_OFF
  183.  
  184. //  Used to turn far pointers into Intel LE 32-bit SEG:OFF far pointer
  185.  
  186. #define MK_DWORD( fp )( (dword) FP_SEG(( fp )) << 16) + FP_OFF(( fp ))
  187.  
  188. //  Do you like booleans?  I like booleans.
  189.  
  190. #ifndef TRUE
  191. #  define TRUE    1
  192. #endif TRUE
  193.  
  194. #ifndef FALSE
  195. #  define FALSE 0
  196. #endif FALSE
  197.  
  198. #ifndef MAYBE
  199. #  define MAYBE Gee... uh... I dunno... maybe.
  200. #endif MAYBE
  201.  
  202. //---------------------------------------------------------------------------
  203. //
  204. //  Type Definitions
  205. //
  206. //---------------------------------------------------------------------------
  207.  
  208. //  DWORDs are primarily used for far calls, like the pointer to the control
  209. //  function, and for offsets into EMBs.  WORDs should be used for handles
  210. //  and most other data types.
  211.  
  212. typedef unsigned long int    dword;    //  32-bit double word
  213. typedef unsigned int        word;    //  16-bit word
  214. typedef unsigned char        byte;    //  8-bit byte
  215.  
  216. //---------------------------------------------------------------------------
  217. //
  218. //  Structures
  219. //
  220. //---------------------------------------------------------------------------
  221.  
  222. //  XMM spec says handles are words and offsets are double words.
  223. //  This structure is passed to XMM MoveMemory function 0x0B.
  224. //  If a NULL handle (0x0000) is passed, the offset is assumed to be a far
  225. //  pointer into conventional memory in Intel DWORD notation
  226.  
  227. typedef struct XMM_Move {
  228.     dword    Length;            //  Number of bytes to move
  229.     word    SourceHandle;        //  Source handle
  230.     dword    SourceOffset;        //  Source offset into block memory
  231.     word    DestHandle;        //  Destination handle
  232.     dword    DestOffset;        //  Destination offset into block memory
  233. } XMM_Move;
  234.  
  235. //---------------------------------------------------------------------------
  236. //
  237. //  External Global Variable Declaration
  238. //
  239. //---------------------------------------------------------------------------
  240.  
  241. extern const char XMMLIB_Version[];    //  String contains XMMLIB version
  242. extern dword XMM_Control;        //  Array stores SEG:OFF of XMM handler
  243. extern word XMM_Version;        //  16-bit BCD of XMM version
  244. extern char XMM_VerString[];        //  String contains XMM version
  245. extern word XMM_HMA;            //  Contains 1 if HMA is available
  246. extern XMM_Move XMM_MoveStruct;        //  Contains move information
  247.  
  248. //---------------------------------------------------------------------------
  249. //
  250. //  Function Prototypes
  251. //
  252. //---------------------------------------------------------------------------
  253.  
  254. extern byte    XMM_Installed();
  255. extern dword    XMM_GetControl();
  256. extern word    XMM_GetVersion();
  257. extern int    XMM_GetVerHigh();
  258. extern int    XMM_GetVerLow();
  259. extern char*    XMM_GetVerString();
  260. extern dword    XMM_Initialize();
  261. extern word    XMM_QueryTotalFree();
  262. extern word    XMM_QueryLargestFree();
  263. extern word    XMM_AllocateBlock(word size);
  264. extern byte    XMM_FreeBlock(word handle);
  265. extern word    XMM_MoveMemory(dword length,
  266.                 word srchnd, dword srcoff,
  267.                 word dsthnd, dword dstoff);
  268. extern dword    XMM_LockBlock(word handle);
  269. extern word    XMM_UnlockBlock(word handle);
  270. extern int    XMM_LockCount(word handle);
  271. extern int    XMM_NumHandles(word handle);
  272. extern word    XMM_BlockSize(word handle);
  273. extern word    XMM_ReallocateBlock(word handle, word length);
  274. extern word    XMM_memcpy(word dsthnd, dword dstoff,
  275.                 word srchnd, dword srcoff,
  276.                 dword n);
  277. extern word    XMM_memcpy(word dsthnd, dword dstoff,
  278.                 byte far* source,
  279.                 dword n);
  280. extern word    XMM_memcpy(byte far* dest,
  281.                 word srchnd, dword srcoff,
  282.                 dword n);
  283. extern word    XMM_memcpy(byte far* dest, byte far* source, dword n);
  284.  
  285. #endif _XMMLIB_H
  286.